概述

1、定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示
2、主要作用:在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
3、如何使用:用户只需要给出指定复杂对象的类型和内容,建造者模式负责按顺序创建复杂对象(把内部的建造过程和细节隐藏起来)
4、解决的问题:
(1)、方便用户创建复杂的对象(不需要知道实现过程)
(2)、代码复用性 & 封装性(将对象构建过程和细节进行封装 & 复用)
5、注意事项:与工厂模式的区别是:建造者模式更加关注与零件装配的顺序,一般用来创建更为复杂的对象

实现方式

代码实现

  • 抽象建造者(builder):描述具体建造者的公共接口,一般用来定义建造细节的方法,并不涉及具体的对象部件的创建。

  • 具体建造者(ConcreteBuilder):描述具体建造者,并实现抽象建造者公共接口。

  • 指挥者(Director):调用具体建造者来创建复杂对象(产品)的各个部分,并按照一定顺序(流程)来建造复杂对象。

  • 产品(Product):描述一个由一系列部件组成较为复杂的对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
    * Builder.java
    * 建造者
    */
    abstract class Builder {
    //地基
    abstract void bulidA();
    //钢筋工程
    abstract void bulidB();
    //铺电线
    abstract void bulidC();
    //粉刷
    abstract void bulidD();
    //完工-获取产品
    abstract Product getProduct();
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    /**
    * Product.java
    * 产品(房子)
    */
    public class Product {
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;
    public String getBuildA() {
    return buildA;
    }
    public void setBuildA(String buildA) {
    this.buildA = buildA;
    }
    public String getBuildB() {
    return buildB;
    }
    public void setBuildB(String buildB) {
    this.buildB = buildB;
    }
    public String getBuildC() {
    return buildC;
    }
    public void setBuildC(String buildC) {
    this.buildC = buildC;
    }
    public String getBuildD() {
    return buildD;
    }
    public void setBuildD(String buildD) {
    this.buildD = buildD;
    }
    @Override
    public String toString() {
    return buildA+"\n"+buildB+"\n"+buildC+"\n"+buildD+"\n"+"房子验收完成";
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    /**
    * ConcreteBuilder.java
    * 具体建造者(工人)
    */
    public class ConcreteBuilder extends Builder{
    private Product product;
    public ConcreteBuilder() {
    product = new Product();
    }
    @Override
    void bulidA() {
    product.setBuildA("地基");
    }
    @Override
    void bulidB() {
    product.setBuildB("钢筋工程");
    }
    @Override
    void bulidC() {
    product.setBuildC("铺电线");
    }
    @Override
    void bulidD() {
    product.setBuildD("粉刷");
    }
    @Override
    Product getProduct() {
    return product;
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    /**
    * Director.java
    * 指挥者
    */
    public class Director {
    //指挥工人按顺序造房
    public Product create(Builder builder) {
    builder.bulidA();
    builder.bulidB();
    builder.bulidC();
    builder.bulidD();
    return builder.getProduct();
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
    * Test.java
    * 测试类
    */
    public class Test {
    public static void main(String[] args) {
    Director director = new Director();
    Product create = director.create(new ConcreteBuilder());
    System.out.println(create.toString());
    }
    }

    总结

  1. Builder 抽象类定义构建的方法
  2. 具体实现类实现Builder相关的方法-叫具体建造者
  3. 指挥者操作操作具体建造者按照顺序创建对象
  4. 产品类有大量属性

    优点

  • 按照顺序创建对象
  • 创建代码可读性好
  • 隐藏对象大量属性,可以设置一些属性的默认值

    缺点

  • 代码冗余
  • 具体建造者内部代码复杂,代码可读性差

    具体实现

  • protobuf生成的实体类
    1
    2
    3
    4
    SimpleRequest.Builder builder = SimpleRequest.newBuilder();
    builder.setId(12341);
    builder.setName("你好");
    SimpleRequest request = builder.build();